{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 数据编码分析\n",
    "\n",
    "*Copyright (c) 2022 Institute for Quantum Computing, Baidu Inc. All Rights Reserved.*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 概览\n",
    "\n",
    "目前很多研究表明变分量子算法（Variational Quantum Algorithms, VQA）有望在近期量子设备上展现出量子优势，其中备受关注的是用其解决监督学习任务。VQA 通常也被称为参数化量子电路 （Parameterized Quantum Circuit, PQC），在本教程中将其分为数据编码电路和量子神经网络两部分。数据编码电路将经典信息编码为量子态。编码后量子态的质量直接影响了后续的分类效果。从核函数的角度分析数据编码，不同的编码方式就对应不同的核函数，其对量子态的分类起着决定性作用 [1,2]。从统计学习理论的角度考察数据编码，它通常决定了算法的表达能力和泛化能力 [3,4]。 因此，我们有必要对数据编码方式进行系统的分析。最近文献 [5] 得到了一些进展，从量子信息的角度严格的分析了数据编码电路的宽度和深度对编码后量子态的影响。\n",
    "\n",
    "接下来本教程围绕文献 [5] 展开，主要分为原理和 Paddle Quantum 实现两部分：先介绍基本概念与主要结论，然后给出具体的实现方案。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 原理"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 基本概念\n",
    "\n",
    "图 1 是将经典数据编码为量子态的流程图。假设经典数据是分布 $D$ 的独立同分布采样，每个经典数据为 $\\pmb x$, 通过数据编码电路后变成了量子态 $\\rho(\\pmb x)$。这里引入分布 $D$ 上的**平均量子态**的概念，即 \n",
    "\n",
    "$$\n",
    "\\bar{\\rho}:=\\mathbf{E}[\\rho(\\pmb x)]. \\tag{1}\n",
    "$$\n",
    "\n",
    "在给定 $M$ 条数据组成的经典数据集 $S$ 时，我们通常使用平均值 \n",
    "\n",
    "$$\n",
    "\\bar{\\rho}:=\\frac{1}{M}\\sum_{j=1}^M\\rho(\\pmb x_j) \\tag{2}\n",
    "$$ \n",
    "\n",
    "近似 $S$ 的平均量子态。\n",
    "\n",
    "![illustration](figures/EncodingAnalysis-fig-illustration.png  \"图 1：经典数据编码为量子态的流程图。\")\n",
    "\n",
    "有很多方法可以衡量量子态之间的距离，常用的有迹距离、保真度、**Petz-Rényi 散度**等等。在本教程中使用 Petz-Rényi 散度作为不同量子态之间距离的度量。具体的，量子态 $\\rho_0$ 和 $\\rho_1$ 的Petz-Rényi 散度定义为\n",
    "\n",
    "$$\n",
    "D_2(\\rho_0||\\rho_1)=logTr[\\rho_0^2\\rho_1^{-1}]. \\tag{3}\n",
    "$$\n",
    "\n",
    "$D_2$ 的取值越小表示两个量子态越接近。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 主要结论\n",
    "\n",
    "接下来我们借助 Petz-Rényi 散度这一度量工具考察编码后的平均量子态与最大混合态之间的距离。不难想到这个距离应该与经典数据集本身的性质和数据编码方式有关。具体的，假设经典数据集的每个特征维度满足一定的独立性且标准差至少为 $\\sigma$, 那么对于如图 2 所示的编码电路（宽度和深度分别为 $n$ 和 $D$）有如下不等式成立\n",
    "\n",
    "$$\n",
    "D_2(\\bar{\\rho}||I/2^n)\\leq log(1+(2^n-1)2^{-D\\sigma^2}), \\tag{4}\n",
    "$$\n",
    "\n",
    "其中 $I/2^n$ 为 $n$ 比特的最大混合态，$I$ 为单位矩阵。\n",
    "\n",
    "![encoding-u3](figures/EncodingAnalysis-fig-u3_circuit.png  \"图 2：更一般的数据编码电路。其中 Etg 表示控制非门和 CZ 门的任意组合。\")\n",
    "\n",
    "更严格的定理描述和证明可以参考文献 [5]，在本教程中我们主要体会这一结论意味着什么以及有那些启发：\n",
    "\n",
    "* 上述结论意味着随着电路深度增加，编码后的平均量子态以指数的速度趋向于最大混合态。例如一个二分类的数据集，0类和1类的平均量子态最终都趋向于最大混合态，那么从量子信息的角度看将无法区分这两类的平均量子态，也即从平均意义下无法区分经典数据特征。\n",
    "\n",
    "* 当经典数据特征维度很高时（例如图片数据）使用角度编码可能不是一个合适的选择，因为这很容易导致很深的数据编码电路，而加宽电路又会遇到贫瘠高原问题，这严重限制了 VQA 的能力。因此经典数据在输入给电路之前需要对其做一些降维操作。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Paddle Quantum 实现 \n",
    "\n",
    "这一节中主要使用 Paddle Quantum 在 MNIST 数据集上完成两个实验：\n",
    "- 考察平均量子态和最大混合态之间的 Petz-Rényi 散度随着数据编码电路的深度的变化趋势；\n",
    "- 考察随着数据编码电路的加深分类准确率的变化。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 首先导入相关的包"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 导入 numpy、paddle 和 paddle_quantum\n",
    "import numpy as np\n",
    "import paddle\n",
    "import paddle_quantum\n",
    "\n",
    "# 构建量子电路\n",
    "from paddle_quantum.ansatz import Circuit\n",
    "\n",
    "# 一些用到的函数\n",
    "from numpy import pi as PI\n",
    "from paddle import matmul, transpose, reshape, real, argmax, cast, mean, concat, real\n",
    "from paddle_quantum.qinfo import pauli_str_to_matrix \n",
    "from paddle_quantum.linalg import dagger\n",
    "import paddle.nn.functional as F\n",
    "\n",
    "# 数据集工具包\n",
    "from paddle_quantum.dataset import MNIST\n",
    "\n",
    "# 作图与计算时间\n",
    "from matplotlib import pyplot as plt\n",
    "from pylab import axes\n",
    "import time"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 参数化量子电路\n",
    "\n",
    "![encoding-ry](figures/EncodingAnalysis-fig-ry_circuit.png \"图 3：参数化量子电路。\")\n",
    "\n",
    "图 3 中左侧红色框为数据编码电路，是图 2 的一个特例，右侧蓝色框为量子神经网络。其中数据编码电路由 $R_y$ 旋转门和控制非门组成，具体的电路深度 $D$ 由数据的特征维度决定。例如在本教程中将使用 MNIST 数据集，由于图片被降采样为 16 维的特征向量，因此在设计实验时选择量子比特数为 8、6、4、3、2 ，则默认情况下对应的电路深度为 2、3、4、6、8, 大于 16 维的位置用 0 填充，即作用 $R_y(0)$. 量子神经网络部分由单比特的通用门 $U3$ 和控制非门构成。具体的电路深度 $L$ 可以自由设置。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 将经典数据编码为量子态\n",
    "\n",
    "这里需要量桨提供的数据集处理工具 `dataset`。使用图 2 所示的数据编码电路将 MNIST 数据中的经典数据编码为量子态并保存起来，以便将其输入给量子神经网络进行训练。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_data, test_data = [], []\n",
    "\n",
    "# 二分类的手写数字类别\n",
    "classes = [3,6]\n",
    "\n",
    "training_data_num = 1000\n",
    "testing_data_num = 200\n",
    "qubit_num_list = [8, 6, 4, 3, 2]\n",
    "\n",
    "# 使用不同的宽度和深度的电路编码经典数据并保存下来\n",
    "for qubit_num in qubit_num_list:\n",
    "    \n",
    "    # 训练数据集\n",
    "    train_dataset = MNIST(mode='train', encoding='real_entangled_encoding', num_qubits=qubit_num,\n",
    "                          classes=classes,\n",
    "                          data_num=training_data_num,\n",
    "                          downscaling_method='resize', target_dimension=16,\n",
    "                          need_relabel=True, return_state=True)\n",
    "\n",
    "    # 验证数据集\n",
    "    val_dataset = MNIST(mode='test', encoding='real_entangled_encoding', num_qubits=qubit_num,\n",
    "                        classes=classes,\n",
    "                        data_num=testing_data_num,\n",
    "                        downscaling_method='resize', target_dimension=16,\n",
    "                        need_relabel=True, return_state=True)\n",
    "\n",
    "    # 获取数据集的输入和标签\n",
    "    train_x, train_y = train_dataset.quantum_image_states, train_dataset.labels\n",
    "    test_x, test_y = val_dataset.quantum_image_states, val_dataset.labels\n",
    "    train_data.append((train_x, train_y))\n",
    "    test_data.append((test_x, test_y))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1000, 256]\n",
      "(1000,)\n",
      "[200, 256]\n",
      "(200,)\n"
     ]
    }
   ],
   "source": [
    "print(train_data[0][0].shape)\n",
    "print(train_data[0][1].shape)\n",
    "print(test_data[0][0].shape)\n",
    "print(test_data[0][1].shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 构建量子神经网络"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 搭建整个优化流程图\n",
    "class Net(paddle.nn.Layer):\n",
    "    \"\"\"\n",
    "    创建模型训练网络\n",
    "    \"\"\"\n",
    "    def __init__(self, n, depth):\n",
    "        # 初始化部分，通过n, depth给出初始电路\n",
    "        super(Net, self).__init__()\n",
    "        self.n = n\n",
    "        self.depth = depth\n",
    "        \n",
    "        self.circuit = Circuit(n)\n",
    "        # 先搭建广义的旋转层\n",
    "        for i in range(n):\n",
    "            self.circuit.rz(qubits_idx=i)\n",
    "            self.circuit.ry(qubits_idx=i)\n",
    "            self.circuit.rz(qubits_idx=i)\n",
    "\n",
    "        # 默认深度为 depth = 1\n",
    "        # 对每一层搭建电路\n",
    "        for d in range(3, depth + 3):\n",
    "            # 搭建纠缠层\n",
    "            for i in range(n-1):\n",
    "                self.circuit.cnot(qubits_idx=[i, i + 1])\n",
    "            self.circuit.cnot(qubits_idx=[n-1, 0])\n",
    "            # 对每一个量子比特搭建Ry\n",
    "            for i in range(n):\n",
    "                self.circuit.ry(qubits_idx=i)\n",
    "\n",
    "    # 定义前向传播机制、计算损失函数 和交叉验证正确率\n",
    "    def forward(self, state_in, label):\n",
    "        \"\"\"\n",
    "        输入：state_in：输入量子态，shape: [-1, 1, 2^n] -- 此教程中为[BATCH, 1, 2^n]\n",
    "             label：输入量子态对应标签，shape: [-1, 1]\n",
    "        计算损失函数：交叉熵损失函数\n",
    "        \"\"\"\n",
    "        # 按照随机初始化的参数 theta \n",
    "        Utheta = self.circuit.unitary_matrix()\n",
    "\n",
    "        # 因为 Utheta是学习到的，我们这里用行向量运算来提速而不会影响训练效果\n",
    "        state_out = matmul(state_in, Utheta)  # 维度 [-1, 1, 2 ** n]\n",
    "\n",
    "        # 测量得到泡利 Z 算符的期望值 <Z>\n",
    "        Ob1 = paddle.to_tensor(pauli_str_to_matrix([[1.0, 'z0']], self.n))\n",
    "        E_Ob1 = matmul(matmul(state_out, Ob1), transpose(paddle.conj(state_out), perm=[0, 2, 1]))\n",
    "        E_Ob1_re = reshape(real(E_Ob1), [-1, 1])\n",
    "\n",
    "        Ob2 = paddle.to_tensor(pauli_str_to_matrix([[1.0, 'x0']], self.n))\n",
    "        E_Ob2 = matmul(matmul(state_out, Ob2), transpose(paddle.conj(state_out), perm=[0, 2, 1]))\n",
    "        E_Ob2_re = reshape(real(E_Ob2), [-1, 1])\n",
    "\n",
    "        outputs = concat([E_Ob1_re, E_Ob2_re], axis=-1)\n",
    "\n",
    "        # 计算损失函数和准确率\n",
    "        loss = F.cross_entropy(outputs, label)\n",
    "        # validation accuracy\n",
    "        acc = mean(cast(argmax(outputs, axis=-1) == label, \"float32\"))\n",
    "        \n",
    "        return loss, acc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 定义一个分类器\n",
    "def QClassifier(train_x, train_y, test_x, test_y, N, D, EPOCH, LR, BATCH, seed=0):\n",
    "    \"\"\"\n",
    "    量子二分类器\n",
    "    \"\"\"\n",
    "    train_y = paddle.to_tensor(train_y, dtype=\"int64\")\n",
    "    test_y = paddle.to_tensor(test_y, dtype=\"int64\")\n",
    "\n",
    "    N_train, in_dim = train_x.shape\n",
    "    \n",
    "    # 定义优化图,Net是用户定义的量子神经网络\n",
    "    paddle.seed(0)\n",
    "    net = Net(n=N, depth=D)\n",
    "\n",
    "    # 一般来说，我们利用Adam优化器来获得相对好的收敛\n",
    "    # 当然你可以改成SGD或者是RMSprop\n",
    "    opt = paddle.optimizer.Adam(learning_rate=LR, parameters=net.parameters())\n",
    "\n",
    "    # 优化循环\n",
    "    for ep in range(EPOCH):\n",
    "        for itr in range(N_train // BATCH):\n",
    "            input_state = train_x[itr * BATCH:(itr + 1) * BATCH]\n",
    "            input_state = reshape(input_state, [-1, 1, 2 ** N])\n",
    "            label = train_y[itr * BATCH:(itr + 1) * BATCH]\n",
    "\n",
    "            test_input_state = reshape(test_x, [-1, 1, 2 ** N])\n",
    "\n",
    "            # 前向传播计算损失函数\n",
    "            train_loss, train_acc = net(state_in=input_state, label=label)\n",
    "\n",
    "            if itr % 3 == 0:\n",
    "                # 计算测试集上的正确率\n",
    "                loss_useless, test_acc = net(state_in=test_input_state, label=test_y)\n",
    "                print(\"epoch:\", ep, \"iter:\", itr,\n",
    "                      \"train loss: %.4f\" % train_loss.numpy(),\n",
    "                      \"train acc: %.4f\" % train_acc,\n",
    "                      \"test acc: %.4f\" % test_acc)\n",
    "\n",
    "            # 反向传播极小化损失函数\n",
    "            train_loss.backward()\n",
    "            opt.minimize(train_loss)\n",
    "            opt.clear_grad()\n",
    "    \n",
    "    # 返回测试集的分类准确率\n",
    "    _, test_acc = net(state_in=test_input_state, label=test_y) \n",
    "    \n",
    "    return test_acc.numpy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "***************************** qubit num : 8 *****************************\n",
      "epoch: 0 iter: 0 train loss: 0.6913 train acc: 0.5200 test acc: 0.4250\n",
      "epoch: 0 iter: 3 train loss: 0.6836 train acc: 0.6500 test acc: 0.5200\n",
      "epoch: 1 iter: 0 train loss: 0.6759 train acc: 0.6850 test acc: 0.5550\n",
      "epoch: 1 iter: 3 train loss: 0.6709 train acc: 0.6950 test acc: 0.5650\n",
      "epoch: 2 iter: 0 train loss: 0.6651 train acc: 0.6650 test acc: 0.5700\n",
      "epoch: 2 iter: 3 train loss: 0.6621 train acc: 0.7050 test acc: 0.6050\n",
      "epoch: 3 iter: 0 train loss: 0.6589 train acc: 0.6900 test acc: 0.6000\n",
      "epoch: 3 iter: 3 train loss: 0.6597 train acc: 0.7050 test acc: 0.6250\n",
      "epoch: 4 iter: 0 train loss: 0.6563 train acc: 0.7150 test acc: 0.6550\n",
      "epoch: 4 iter: 3 train loss: 0.6566 train acc: 0.7250 test acc: 0.6700\n",
      "***************************** qubit num : 6 *****************************\n",
      "epoch: 0 iter: 0 train loss: 0.6966 train acc: 0.4900 test acc: 0.5250\n",
      "epoch: 0 iter: 3 train loss: 0.6938 train acc: 0.4850 test acc: 0.5450\n",
      "epoch: 1 iter: 0 train loss: 0.6884 train acc: 0.5350 test acc: 0.5450\n",
      "epoch: 1 iter: 3 train loss: 0.6862 train acc: 0.5400 test acc: 0.5700\n",
      "epoch: 2 iter: 0 train loss: 0.6775 train acc: 0.5750 test acc: 0.5850\n",
      "epoch: 2 iter: 3 train loss: 0.6744 train acc: 0.6100 test acc: 0.6000\n",
      "epoch: 3 iter: 0 train loss: 0.6642 train acc: 0.6350 test acc: 0.5950\n",
      "epoch: 3 iter: 3 train loss: 0.6615 train acc: 0.6450 test acc: 0.6200\n",
      "epoch: 4 iter: 0 train loss: 0.6526 train acc: 0.6900 test acc: 0.6300\n",
      "epoch: 4 iter: 3 train loss: 0.6560 train acc: 0.6250 test acc: 0.6350\n",
      "***************************** qubit num : 4 *****************************\n",
      "epoch: 0 iter: 0 train loss: 0.7081 train acc: 0.4650 test acc: 0.5350\n",
      "epoch: 0 iter: 3 train loss: 0.6994 train acc: 0.4950 test acc: 0.5900\n",
      "epoch: 1 iter: 0 train loss: 0.6902 train acc: 0.5450 test acc: 0.5750\n",
      "epoch: 1 iter: 3 train loss: 0.6942 train acc: 0.5150 test acc: 0.5800\n",
      "epoch: 2 iter: 0 train loss: 0.6869 train acc: 0.6100 test acc: 0.5850\n",
      "epoch: 2 iter: 3 train loss: 0.6923 train acc: 0.5150 test acc: 0.6000\n",
      "epoch: 3 iter: 0 train loss: 0.6825 train acc: 0.5700 test acc: 0.6050\n",
      "epoch: 3 iter: 3 train loss: 0.6917 train acc: 0.5200 test acc: 0.5950\n",
      "epoch: 4 iter: 0 train loss: 0.6776 train acc: 0.5850 test acc: 0.5800\n",
      "epoch: 4 iter: 3 train loss: 0.6901 train acc: 0.5450 test acc: 0.6050\n",
      "***************************** qubit num : 3 *****************************\n",
      "epoch: 0 iter: 0 train loss: 0.7104 train acc: 0.4550 test acc: 0.5000\n",
      "epoch: 0 iter: 3 train loss: 0.6931 train acc: 0.4950 test acc: 0.4900\n",
      "epoch: 1 iter: 0 train loss: 0.6928 train acc: 0.4600 test acc: 0.4700\n",
      "epoch: 1 iter: 3 train loss: 0.6968 train acc: 0.4800 test acc: 0.4800\n",
      "epoch: 2 iter: 0 train loss: 0.6964 train acc: 0.5100 test acc: 0.4750\n",
      "epoch: 2 iter: 3 train loss: 0.7004 train acc: 0.5150 test acc: 0.4600\n",
      "epoch: 3 iter: 0 train loss: 0.6961 train acc: 0.5050 test acc: 0.4800\n",
      "epoch: 3 iter: 3 train loss: 0.6957 train acc: 0.5300 test acc: 0.4850\n",
      "epoch: 4 iter: 0 train loss: 0.6938 train acc: 0.5250 test acc: 0.5150\n",
      "epoch: 4 iter: 3 train loss: 0.6919 train acc: 0.5150 test acc: 0.5250\n",
      "***************************** qubit num : 2 *****************************\n",
      "epoch: 0 iter: 0 train loss: 0.7031 train acc: 0.5450 test acc: 0.4800\n",
      "epoch: 0 iter: 3 train loss: 0.6960 train acc: 0.5350 test acc: 0.4550\n",
      "epoch: 1 iter: 0 train loss: 0.6932 train acc: 0.5100 test acc: 0.5100\n",
      "epoch: 1 iter: 3 train loss: 0.6930 train acc: 0.5250 test acc: 0.5200\n",
      "epoch: 2 iter: 0 train loss: 0.6930 train acc: 0.5150 test acc: 0.4750\n",
      "epoch: 2 iter: 3 train loss: 0.6933 train acc: 0.5050 test acc: 0.4600\n",
      "epoch: 3 iter: 0 train loss: 0.6925 train acc: 0.5400 test acc: 0.4600\n",
      "epoch: 3 iter: 3 train loss: 0.6909 train acc: 0.5350 test acc: 0.4700\n",
      "epoch: 4 iter: 0 train loss: 0.6939 train acc: 0.5450 test acc: 0.4750\n",
      "epoch: 4 iter: 3 train loss: 0.6853 train acc: 0.5600 test acc: 0.4750\n",
      "主程序段总共运行了 125.62448906898499 秒\n"
     ]
    }
   ],
   "source": [
    "time_start = time.time()\n",
    "\n",
    "acc_list = []\n",
    "\n",
    "for i in range(5):\n",
    "    print('***************************** qubit num : %s *****************************'%qubit_num_list[i])\n",
    "    train_x, train_y = train_data[i]\n",
    "    test_x, test_y = test_data[i]\n",
    "\n",
    "    acc = QClassifier(\n",
    "        train_x,\n",
    "        train_y,\n",
    "        test_x,\n",
    "        test_y,\n",
    "        N=qubit_num_list[i],      # 所需的量子比特数量\n",
    "        D=qubit_num_list[i] + 2,  # 采用的电路深度\n",
    "        EPOCH=5,                  # 训练 epoch 轮数\n",
    "        LR=0.05,                  # 设置学习速率\n",
    "        BATCH=200,                # 训练时 batch 的大小\n",
    "        seed=0\n",
    "    )\n",
    "    acc_list.append(acc)      \n",
    "\n",
    "time_span = time.time() - time_start\n",
    "print('主程序段总共运行了', time_span, '秒')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 考察平均量子态与最大混合态的 Petz-Rényi 散度"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1.9842463368536747, 0.5256437464833253, 0.1964853652901484, 0.05162865627740749, 0.022790754263846934]\n",
      "[1.8628793706046225, 0.6064395532199834, 0.1529884926031612, 0.04173701231534178, 0.009023512622560221]\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAcAAAAEnCAYAAAA+ZJNJAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAAsTAAALEwEAmpwYAABNaElEQVR4nO3dd3hU1dbA4d9KSCgBQglNEAKidERAQIpUFZGIiAUEpSl28ROUq8j1WkBU5GJBuSCCSBFFAbFgAYIgCFJsiBSlC1JCL0lI1vfHmZAQUibJJCczWe/zzHPm9HUoWdn77CKqijHGGFPQBLkdgDHGGOMGS4DGGGMKJEuAxhhjCiRLgMYYYwokS4DGGGMKpEJuB1DQRUREaGRkpNthGGNMwFq7du1BVS2XerslQJdFRkayZs0at8MwxpiAJSI70tpuVaDGGGMKJEuAxhhjCiRLgMYYYwokS4DGGGMKJEuAxhhjCiRLgMYYYwokS4CBYO9eeOABuOIKtyMxxhi/Yf0A/dnevfD88zBlCiQmQlyc2xEZ47rY2FhiYmI4fvw4CQkJbodjckFwcDAlSpSgTJkyFC5cONvXsQToj/buZcYrdzKcRewsD1Xvg5GLoPevbgdmjLtiY2PZuXMnpUuXJjIykpCQEETE7bCMD6kq8fHxHDt2jJ07d1K1atVsJ0FLgC4RkSggqmbNmlk+d8bg9gy6dBOnQp31HaVgUJTzvbfPIjTG/8TExFC6dGkiIiLcDsXkEhEhNDT03N9xTEwMlSpVyta17B2gS1R1gaoOCg8Pz/K5w5ufPJf8kpwKheEdfRScMX7q+PHjlCxZ0u0wTB4pWbIkx48fz/b5lgD90M4Te9LeHg6o5m0wxuQjCQkJhISEuB2GySMhISE5es9rCdAPVQ2vmub2i48BR47kaSzG5Df2zq/gyOnftSVAPzSy40iKhRS7YHuNuq2JKxnmlAITE12IzBhj/Ic1gvFDvRs4TV2GLxrOzqM7uTj8YhpVaMSnmz/l2vevZc5vdYk4EgcTJ0KQ/Y5jjDFpsZ+Ofqp3g95sf3Q7ic8ksuPRHczvNZ/p3afzw+4faF78A34vcQasKsgYk8rUqVMREaKjo7N9jcjISNq1a+ezmNxiCTCA9G7Ym+h+0ZwsHkqL8p/y9V/fwKFDYJ2BjQk40dHRiMi5T3BwMKVLl6Z+/fr07duXhQsXonnYKG7cuHFMnTrV6+Pj4+O57777aNKkCRERERQuXJjq1atz++23s379+twLNAWrAg0wLaq04Md7fuS2ObdRUkOhTRto1QomTXI7NGNMLujVqxddunRBVTl+/DibNm1i3rx5TJs2jU6dOvHRRx9RqlSpc8ffeeed9OzZk9DQ0PQvmolNmzZd0ABl3LhxREZG0q9fP6+uERcXx5o1a2jVqhV33nknJUqUYOfOnUyZMoXmzZuzcOFCOnTokO0YvWEJMABdHH4xKwascP6B3n03c6ud4oaEOEKDs/8P3hiTPzVu3Jg+ffqct23s2LE88cQTjB07ll69evHll1+e2xccHExwcHCO7pmT4ceShIWFsWbNmgu233fffVStWpUxY8bkegK0KtAAlfTb2c93dOTm30bw5uo3YdkyGy/UGF/I5wPQBwcH8+qrr9K6dWsWLlzI8uXLz+1L7x3g9u3b6dGjByVLlqRkyZJ069aNbdu2pfm+L/U2EWHHjh0sXbr0vGrZ7du3Zzn28uXLU6RIEQ4fPpzlc7PKSoAB7vKKl/NVn69or9WgTn0Sn/wXQc8973ZYxvgnPxuAfuDAgSxfvpzPP/+c1q1bp3vcoUOHaNOmDf/88w/33XcfderUYdmyZbRv356TJ09mep/333+f//u//yMiIoLhw4ef216uXLlMz01ISODw4cOcPXuWXbt2MWbMGE6cOEGXLl28e8gcsBJgAXDtJdcSUrMWB6ZN4IoK8/h88+duh2RM3mvXDpIaacTHO+vTpzvrp04567NnO+tHjzrrn3zirP/2G1x0EURGwuTJcObM+clv1y7n+G+/ddb/+stZX7rUWd+0yVlfsSL5enmgYcOGAGzevDnD41566SV2797NlClTeP3117n//vuZOXMmt912GwcPHsz0Pn369CEsLIwKFSrQp0+fc5+wsLBMz924cSPlypWjUqVKNGvWjK+++oonn3ySJ5980ruHzAFLgAVI3A2dCS4UQtSsKF4deQN6+rTbIRnjHwYNckp/cXH5vtSXUtK4qMeOHcvwuAULFlCpUiV69ep13vahQ4fmWmxJqlevzjfffMPnn3/Oa6+9xmWXXcbRo0eJjY3N9XtbFWgBUrlkZZb1X0bf/3VmaMwXbJjUlQkPfmmNY0zBkPKdV0jI+evFip2/Hh5+/vonnyRXfSYkXJgEL774/ONr1Dh/vVat89fr18/mQ2RNUuLLbIDwbdu20axZM4JSDZxRvnz581qQ5oawsDA6dep0bn3AgAE0btyYHj16sHDhwly9t5UAC5iw0DA+fGgpI2rfy5TDi+k0rRMHTh5wOyxj8reKFWH8eKdq8+67oWhRyEE3grzyyy+/AFCrVi2XI/Fe8eLFufnmm/nqq6/4888/c/VelgALoCAJ4rnbJzCrxyx+3LOaZqOq89v21W6HZUz+lzoRNmrkdkQZmjx5MgA33HBDhsdFRkaydetWElONIbx//36OeDnAvi8HIT/teT0TExPjs2umxRKgD4jIpSKyUEROiMgBEXlDRC4crTqf6Vm/J0sv/jex8ae5akYHaxxjjLeSEmEejViSVQkJCQwdOpTly5fTpUsXWrVqleHxUVFR7N27l1mzZp23fcyYMV7fs3jx4llKWAcOHLgg4QLs27ePjz76iOLFi1OvXj2vr5cd9g4wh0SkFLAE2AHcApQHxgLlgJ7uReadZn2f4sd9t3Ljpz1Zsn0JN1S/1nk/YozxC+vWrWO6pzVrypFgduzYwbXXXsvMmTMzvcawYcOYOXMm/fv3Z/Xq1dSuXZtly5axYsUKIiIivCrdtWjRgsmTJzNixAjq1KlDUFAQUVFR6bYEnTFjBuPGjaN79+5Ur16d0NBQNm/ezHvvvcfhw4d55513KFYsd8sRlgBz7l6gNNBIVQ8CiMhZYIaIPK+qG1yNzguVK17Ksv7LKPzG2/Cftmz94C0uvqgOhQvlfLQHY0zumjVrFrNmzSIoKIjixYtTpUoV2rZtS69evejcubNX14iIiGD58uUMGTKEd999FxGhffv2LFmyhCuvvJKiRYtmeo2RI0cSExPD+PHjOXLkCKrKtm3b0k2Abdq0Yc2aNXz22Wfs3buXuLg4KlSoQKdOnRg8eDAtW7bM0p9DdkheDpYaiERkKXBUVW9Msa0wcBR4WlUzrENo2rSppjUckCvmzuXkxx9Qq/H3XF3tamb2yPw3R2Pyk40bN1KnTh23wwgYhw4dIiIignvvvZcJEya4HU6avPk7F5G1qto09faAfAcoIrVEZLCITBeRP0QkUURURG7x4tw7RGSZiBz1vNNbIyIPikh6f1Z1gN9TblDVWOBPoHbOnyYPde9O2PTZjL1uLE9e8TDkwVBExpj84XQa/YJHjx4NwDXXXJPX4eSJQK0CvR8YnNWTRGQ88ABwBlgExAMdgTeBjiJyi6qmfmtbGjiSxuUOA2WyGkN+cFvdW6FjRzh1isefa02baldzY60bMz/RGOO3unTpQrVq1WjcuDGJiYksWrSIzz77jJYtW3LTTTe5HV6uCMgSIPAb8ApwO1ATWJrZCSLSAyf57QMaqmpXVe0OXApsBLoDD+daxPmJCDz+OCeHPMyS7dHc9MFNvPz9y3k6t5gxJm917dqV9evXM2LECJ544gk2bNjAkCFDWLhwYY5nj8ivArIEqKrvpFz3sn9K0sBzw1R1S4pr/SMi9wPRwL9E5I1UpcDDQKk0rlca+CMLYecv119PGPBdfHf6TY5i2LfD2HBgAxO7TrTGMcYEoCFDhjBkyBC3w8hTgVoCzBIRqQI0AeKAj1LvV9WlwB6gItAi1e6NOO8BU16vMHAJ/pwAPYrFKbNH/Mx/9tdl2s/T6DCtA/tP7nc7LGOMybGALAFmQ9KkXhtUNb0Ron8EKnuOXZFi+xfACBEpq6qHPNu6A4U9+y4gIoOAQQAVKlS4YF6u/Cb838/QqXJlNOEXRv8xmoZvNGRk/ZFcUvwSt0Mz5jzh4eEcP37c7TBMHjpz5ky2f4ZaAnRU9yx3ZHDMzlTHJvkfzrvB+SLyPMkd4Wer6u+kQVUnAhPB6QaRerLJfMcTXyvtTtcX/qFb8FwG/zKYmT1mWuMYk69s3LiREiVKuB2GyUNFihThimxOTGxVoI7inmVGMz+e8CzP+9+lqkeADp79nwD/BWYDA3wbYj7w5580fXk6PybeTd1ydRn27TDiE+LdjsoYY7LFSoA+oKqbAe+GXPBnNWvCL79wUWQkS88O58CpA4QEhxB7NhZFKVKoiNsRGmOM16wE6Egq3WU0fXFSKbFgv2CoXh1EKLo/hqq33g3bt3PvZ/fScVpHKw0aY/yKlQAd2z3Lahkcc3GqY3NERKKAqJo1a/ricnnvn39g0yb45x+6XtaVP2P+JCTYBtE2xvgPS4COpDlN6olI0XRagl6Z6tgcUdUFwIKmTZve44vr5bnGjWHLFggN5Raag2cYpaXbl3L4zGFuqn2Tu/EZY0wmrAoUUNVdwDogFLg19X4RaQtUwRklZmXeRpePJc2I/eGHULs2/PUXL694mZtn38yLy160kWOMyYemTp2KiOSo+1VkZCT5vvW6FywBJnvRs3xJRM7VS4pIeeAtz+roNMYCNXXqQPPmULEic26dw+31b+epxU9x17y7OHP2jNvRGROQoqOjEZFzn+DgYEqXLk39+vXp27cvCxcuzNNfQseNG8fUqVOzfN7Zs2d5/fXXady4MWFhYYSHh9O4cWP+97//+T7IVAJyOiQRaUxy0gKoi9N9YQtwbspiVW2R6ry3cAbSPgN8S/Jg2CWBecAtqprgoxiT3gHes2XLlkyP9xuxseju3YzcM4sRS0bQokoL5t4+l4rFK7odmSkACtJ0SNHR0bRv355evXrRpUsXVPW8CXF37txJp06d+OijjyhVqtS58xISEoiPjyc0NJSgoOyVgWJjYxERQpNqgXBKhZGRkVkqWcbFxXHjjTeyZMkSevfuTYsWLTh79ixbtmyhaNGijBo1KtNr5GQ6JFQ14D5AO0Az+6Rz7h3A98AxnH6Ba4EHgaDciLVJkyYaUO6+W7VCBdUjR3TOhjlabGQxvXjsxbp+73q3IzMFwO+//+52CHlmyZIlCugrr7xywb6zZ8/qY489poB27tw5T+KpVq2atm3bNkvnPP300xocHKyLFy/O9n29+TsH1mgaP38DsgpUVaNVVTL7pHPuTFVtpaolVTVMVZuo6ni1qk/vPP44jBoF4eH0qNuD5f2Xoyit3m3F3I1z3Y7OmGyb8esMIsdFEvRsEJHjIpnx6wy3Q0pXcHAwr776Kq1bt2bhwoUsX7783L703gFu376dHj16ULJkSUqWLEm3bt3Ytm1bmu/7Um8TEXbs2MHSpUvPq5bdvn17ujGePHmS1157jW7dutG+fftzJdi8FJAJ0LjosstggGcQnF9+4Yp9sPru1TQo34BbP7qVbYe3uRufMdkw49cZDFowiB1Hd6AoO47uYNCCQfk6CQIMHDgQgM8//zzD4w4dOkSbNm1YsGAB/fr146WXXiIsLIz27dtz8mRGA2Q53n//fSIiIqhduzbvv//+uU+5cuXSPWfZsmUcP36cJk2aMHjw4HOJt1y5cjz11FOcPXs2aw+bDdYNwuQOVScRxsdTaf16ovtFs2TbEqqXru7Zrd5OU2WMT7Sb2i7TY7pe1pWhLYeeO75fo370a9SPf337L07Fnzrv2FPxpxg4fyCT1k46ty3p+IOnDnLLh7cw5KohRNWKYtPBTdz72b3nnR/dLzrHz5SZhg0bArB58+YMj3vppZfYvXs306dPp3fv3gDcf//9PPHEE7zyyiuZ3qdPnz48/fTTVKhQgT59+ngV26ZNmwCn8UxoaCgvv/wyZcuWZcaMGbz44ovs2bOH9957z6trZZeVAF0iIlEiMvHo0aNuh5I7RGDOHOcTFESRQkW4/tLrAfhyy5e0ntLaplUyfmPPsT1pbo9NiM3jSLKmZMmSABw7dizD4xYsWEClSpXo1avXeduHDh2aa7ElVXfGxMSwaNEi7r//fm677Tbmz59Pu3btmDZtGhs3bsy1+4OVAF2j/t4R3huRkcnfx4yB1q2hRQviEuIQhGIhxVwLzRQ8WS1xpTy+anhVdhy9cLKYauHV0rxuRLGI87bXiqiVJyW+1JISX1IiTM+2bdto1qzZBa1Cy5cvf14LUl8qWrQoAC1atKBWrVrn7bvrrruIjo4mOjo6V1v1WgnQ5L4TJ+B//wNPH6FutbuxrP8yiocW50TcCb7c8qW78RmTiZEdR17wC1uxkGKM7DjSpYi888svvwBckGDygypVqgBQseKFXaQqVaoEwOHDh3M1BkuAJvcVLw4rVsD48c56ivd/Ly57kS4zu3Drh7dSbVw1v2hhZwqe3g16MzFqItXCqyEI1cKrMTFqIr0b9HY7tAxNnjwZgBtuuCHD4yIjI9m6dSuJiec3dt+/fz9Hjhzx6l5ZfaffrFkzAHbv3n3BvqRt5cuXz9I1s8oSoMkb5cpBcDAcOQLt24OnCfaItiNoWaUlczbOYefRnX7Vws4ULL0b9Gb7o9tJfCaR7Y9uz9fJLyEhgaFDh7J8+XK6dOlCq1atMjw+KiqKvXv3MmvWrPO2jxkzxut7Fi9enJiYmMwP9KhevTqtWrVi9erVrFu37rzYJ02aRKFChbj22mu9vl522DtAk7diY+HoUadaFChSqAi7j1/4G+Cp+FMMXzQ8X/+QMSY/WLduHdOnTwc4bySYHTt2cO211zJz5sxMrzFs2DBmzpxJ//79Wb16NbVr12bZsmWsWLGCiIgIr0p3LVq0YPLkyYwYMYI6deoQFBREVFQUYWHpzzL3xhtv0KZNGzp16sQjjzxC2bJlmT17NqtXr+bf//43VatW9f4PIhssAbrE76dDyq4KFWDNGqc0CHD0KLuO7krz0J1Hd+ZhYMb4p1mzZjFr1iyCgoIoXrw4VapUoW3btvTq1YvOnb2bpzsiIoLly5czZMgQ3n33XUSE9u3bs2TJEq688spzDVYyMnLkSGJiYhg/fjxHjhxBVdm2bVuGCfCKK65gxYoVPP3004wbN44zZ85Qp04dpkyZQr9+/bz9I8i2gBwL1J80bdpU16xZ43YY7li+HKKiiBxWmB2x/1yw++KSF7Pz/ywJGu8VpLFA88KhQ4eIiIjg3nvvZcKECW6Hk6acjAVq7wCNe+rUga5dGXn1fy7sEqFQfPf+CzofG2Nyx+nTF06DOnr0aACuueaavA4nT1gVqHFP2bLw/vv0BggrzvAvhrAzdj9Vj8ENm4UtZWJtTkFj8kiXLl2oVq0ajRs3JjExkUWLFvHZZ5/RsmVLbrrpJrfDyxWWAI379u6l933j6f3DfggJgfh4QFFApoVxPPY4IcEhFClUxO1IjQlYXbt2Zdq0acydO5fTp09TpUoVhgwZwjPPPENw0jv7AJPtBCgiZYH2wBVABaAUcBjYjzO7erSqHvJBjCbQ9ewJq1c73+Pjz20W4GziWTrP6Ez5sPJ8ctsnNn6oMblkyJAhDBkyxO0w8lSWEqCIFAJuBR4ArsL5GZXWTyQFVERW4ExMO0dVc39ob+OfZs+G55+HKVMgIQHi4s7tKhRUiLsa3kX5sPKW/IwxPuV1K1ARuRMYBVyEk/T+AVYCv+PMsn4MZ+b0sjgzsF8FlMdJhnuAp1R1uo/j91sBOyN8Tuzb5yTCd95JToKp/n2u2LWCZpWbUSjIau/NhawVaMGT661ARWQVMBUIBl4FGqhqJVW9WVWfVtWxqvqOZzlcVburakWgIfBfnJLmeyLyQ9YeLXCp6gJVHRQeHu52KPlHxYrOcGk7dsC990KjRs72GTPg1Ck2H9rM1VOu5q65d5GQmOBqqCb/soZTBUdO/6697QZxMfAIUE1Vn1DVDd6cpKq/qepQoBowGMjdbv0mMFSsCBMmwPr18NtvcOed8PbbXFb2MkZ2GMms32Yx4NMBlgTNBYKDg4lP8R7ZBLb4+PgcNdDxth7pElW9sJOIl1Q1HnhTRCZn9xqmgKpfH5YtA8/AucPq3E18Qhwjov9NISnEpBsnESTWndU4SpQowbFjx4iIiHA7FJMHjh07RokSJbJ9vlc/OXKS/HLjOqaAadXK6R5x+jRcfTVPf/A3/77637z707s88PkDVuVlzilTpgyHDx/m4MGDxMXF2b+NAKSqxMXFcfDgQQ4fPkyZMmWyfS1rSWD8R+HCMGAANGzIf9p1Ii4hjtHfjyYkKITXr3/dWokaChcuTNWqVYmJiWH79u0kJFg1eSAKDg6mRIkSVK1alcKFC2f7OpYAjf8ICgJPPyUBRm2tRjwtefXHNwkJDuHVa1+1JGgoXLgwlSpVOjepqjHpybQKVERKi8goEZkjIuNF5F4RaSEixTI715jcJGvX8srK4gxu9gjjfxzPxoMb3Q7JGONHMu0HKCKfAx2AxUAEUB8oCiQCfwLrVbVnLscZsAr0bBA5pQqxsWjhwmzYuoL6m49AJjNfG2MKnpz0A2wLPKiqN6hqc6AETkf3PsA8wDqyZYOIRInIxKNHj7odiv8SgSJFEBHqv/MpdO/O9CWv8cJ3L7gdmTHGD3hTAtwCPKSqX+VNSAWLlQB9JDYWVqxg4LHpbDuyja+6ziakbDm3ozLG5AM5KQH+D+jh+5CM8aHChaF9eyZGTeTz6k8TUqMm8Yu/dTsqY0w+5k0CLAR0EJEXRCT7PQ6NyQPBQcEUrVmb4z2iaLt1OK+vet3tkIwx+ZQ3CfAxoAbwFLBfRL4TkddFZICINBaR0NwN0ZgsuugiikyaQqVSVRi8cDBvP3JV8nRLxhjjkWkCVNXyQGXgeuDfwA6gHfA2sAY4novxGZMtIcEhzOoxi6iLO/FA2R+YtOptt0MyxuQzXnWEV9W9wF7gXEMYEQnBaQ3aIHdCMyZnQoND+eiuz+g+80bu3fYeIT+1pd/JS+GSS5wBt40xBVq2R4LxDHD9s+djTL5UuFBhPrljPjfOupEB8wcQEl2a3oWvhIUL3Q7NGOMyG0bfBLwihYowr+c82kW24652R/hwaGdnR2zsebPPG2MKliwlQBFpKyKTRORLEXlXRDIcdkNEhonI4pyFaEzOFQspxoJeC2hVtRV3rBhK9PZoGDYMWreGM2fcDs8Y4wKvq0BF5D/AiKRVz7KviHwL3Kmq+9M4rTbOSDLGuC4sNIzP7/ickctG0qJKC2h7GEqUgCJF3A7NGOMCr0qAItIWpwVoIvAu8BDwOnAMuAZYJSI1civIQGRDobmjROESjO40miKFinC4czuWDuzk7Ni8Ge67D06ccDdAY0ye8bYK9CFAgTtU9R5VfUtVH8Up4S0GqgHfiUit3Akz8KjqAlUdFB5uQ6m6ZcjXQ7jxgxs5fPowLF0Kn3wCR464HZYxJo94mwCvAn5T1Y9SblTVf4DrcEqFFwHRIlLPtyEakzvGXDuGebfPo3TR0nDPPbBlC1Sp4uxcuNCZbcIYE7C8TYDlgN/T2qGqCap6N/AGUAFYLCINfRSfMbmmTNEytK/eHoCZv87kuyOeHj3ffgvXXw+zZrkYnTEmt3mbAM8AYRkdoKqDgf/iJMtFInJFDmMzJk/EJ8QzatkouszowopdK6BjR5g9G26/3Tng9Gl3AzTG5ApvE+BmoElmB6nqEGAMUBb4FmekGGPytZDgEL658xsuKnERnad3ZtWe1XDbbRAcDMePQ6NG8N//uh2mMcbHvE2A3wEVRaRlZgeq6hPAy0Bp4IL5l4zJjyqVqMTivospF1aO66Zfx9q/1zo7goLg6quhqf1TNibQeJsAP8fp+/eoNwer6r+AUST3FzQm36tSsgpL+i6hdNHSXPP+Nfy07ycIC4NJk6BNG+egCRPg449djdMY4xtZKQFegzMDhFdU9WmgGzAgG3EZ44qq4VVZfNdiiocWp9O0Tvy2/7fknYmJMGMGTJ9uLUSNCQCiXvxHFpE2qrosD+IpcJo2bapr1qxxOwyTytaYrbSd2paziWeJ7htNnXJ1nB3x8U6jmJIlYf9+51O/vrvBGmMyJCJrVfWC9xjelgCXisheEZkgIp1FJNuzSBjjD2qWqcniuxYTFhLGnuN7kneEhDjJD2DoUKdq9Ngxd4I0xuSItyXA14CbgItxRoQ5hvNe8BNgoaqeysUYA5qVAPO3uIQ4QoNDATgVf4piIcWSd/7zjzPTfFSU5+A4CA11IUpjTEZyVAJU1cGqWg1ohtPCcx9wB/ARcEBE5orInSJS2pdBG+O2pOQ37edp1B1fl11HdyXvrFAhOfktWgS1asHGjS5EaYzJjixNh6Sqa1T1SVWtA9QDngE24TR2mQrsE5GvReQ+Eank82iNcUnDCg1peXFLyoWVS/uA8HCoVw+qVs3bwIwx2eZVFWimFxGpBvQAbgZa4CTWRGAVMBeYq6p/5vhGAciqQP3PkTNHOBl3ksolK6d9QHw8PP6486nsOWbvXnj+eVi5Etavz7tgjTE5bgSTIVXdoapjVbU1zqDY9wOLcDrCvwxsFpHHfHEvY9ykqtw8+2bav9eevcf3pn3QL7/AO+/AihVO4nvgAahRAyZPhp9+ytN4jTHp80kCTElV96vq/1T1OqA80BeYnxv38mc2H6B/EhFe6PACfx//mw7TOvDPiX8uPKhJEyf5LVniJL5Jk5xZ5+Pi8j5gY0y6fFIFarLPqkD903c7vuP6GddTo3QNlvRdQkSxiPMPaNsWli93Os+nZv/njMlTOaoCFZE1IjLR07ilmYgU9n2IxviPq6tdzYJeC9gas5VO0zoRczrm/ANmz3ZmmC9a9MKuETffDL+nObuYMSYPeVst2RgYCIwHVgLHReRnEZkiIg+LSEsRKZbxJYwJLB2qd2B+z/n8cfAPrn3/Wo6cOZK8s2JFGD8e/voL7r77/ET4/ffJpcCzZ/M8bmOMw9uO8P1wkmBj4HLOnxsw6QKJwBZgHbDWs1yvqjZMRgasCtT/fbHlC7rP7k6jio345s5vKFm45IUH7dvntAJdsQJWrUpOhg89BNu2wYIFzswTxhify2lH+Kmq+oinlWdJnHn++gBjgaXAUSAYqI3TQX4MsBg4LCKbffMIxuRPXS7twke3fsS6vet4aflLaR+UVCJcv/78KtFateDyy5OT36ZNuR+wMQbwYSMYEalBcimxMXAFzuzwqqrBPrlJALISYOBYvnM5zSo3Ozd6TJZt2QK1a8Prr8ODD/o2OGMKsFztBwigqn+p6hxVfUpVO6tqBaAq0N1X9zAmP2tdtTWhwaEcPHWQh754iCnrpxA5LpKgZ4OIHBfJjF9nZHyBKlVg7Fi45RZnfcMGZ4g1azVqTK6wbhAusxJg4Jn/x3xu++g2giSIMwlnzm0vFlKMiVET6d2gt3cXGjAA5s6FnTuhRIlcitaYwJfrJUBjjKNb7W6UL17+vOQHzmwSwxcN9/5Cb70F33yTnPwefdTpXG+M8Qmv5vUTkXdz4d7zVPXTXLiuMa7bc2xPmtt3Ht3p/UWKFIGmnl9aDxyATz6B6tWhffvkalGRHEZqTMHl7cS2/XLh3tsBS4AmIFUNr8qOozsu2F4itAT7TuyjYvGKWbtguXKwdWty4vvsM6dbxccfw8UX+yBiYwoebxNg+1y49/ZcuKYx+cLIjiMZtGAQp+KT54oOlmCOxR0jclwkdze+mydaPUHV8CxMn5R6RJmSJZ3uFQB//w2VKlmJ0JgssEYwLrNGMIFrxq8zGL5oODuP7qRqeFVGdhxJ88rNGb18NNN+noai3NnwTp5q8xQ1y9TM/o0SEqBuXWjWDN5/33cPYEyASK8RjCVAl1kCLJh2Hd3FKyteYdK6SUy4YQJ9G/VFVZHslOASEmD6dKc0eN11EBsLCxc6s9Xb6DLGWALMrywBFmz/nPiHMkXLEBIcwtiVY/lux3d8cMsHFClUJPsXnToV+veH776DNm18Fqsx/iq9BOjtO0BjTC6oULzCue8hQSEUCip0LvltjdmavarRO+90Gs20bu2sv/ceFC4Mt99u7wiNScFKgD4gIjWBoUALoD7wh6rW9+ZcKwGatOw+tpsar9WgeZXmDG8znOsuuS571aOq0K4dhIXBF1/4PE5j/EGOSoDWDzBT9YAbgFU4gwvYixeTI2WLluXVa1/l5RUvc/2M62lSqQnD2wynW+1uBEkW/nmJOJ3nDx921g8ehOuvd4Zcs+pRU8BZP0DfWKCq8wFEZCpwwW8axmRF0ZCiPNz8Ye5tei/Tfp7G6OWjufnDm6lXrh5PtXmK2+rdRqEgL//7BgVB2bLO97//hvj45PXjx525CgvZ2xBT8Hg7H2DbXLj3dlW9sKewn0tKgFYFanzpbOJZPtzwISOXjeT3A79zSelLGN5mOP2v6J/1i6kmvwt86CGnhPjTTxAS4tOYjckvctoIZrGbUxqJSC2gM3AlTunqMkCAW1V1Tibn3gHcDzTEmbPwD2AK8LaqJuZm3Mb4SqGgQtzR4A561u/J/D/mM3LZSL7565tzCTA+IZ6QYC8TWMp3iZ07Q9WqyckvOhpatbJkaAoEb18muN107H5gHNAbqIWX8YjIeGAGTtJcBnyDkzzfBOaIZOVlijHuC5Igutfpzo/3/MjEqIkA/PrPr1QdV5XlO5dn/YJdu8ITTzjf//oLOnaE0aN9GLEx+Ze3JcA060lFJAKn5WMYsA9Yr6rHfBRbSr8BrwBrgLXAZCDDalkR6QE84InralXd4tleAViCM0/hw8Brqc4LByp5EdNOVT2V+WHG+J6IUDy0+Ln15pWbU7dcXQA27N9ApRKVKFO0TNYuWr06fPpp8gDcP/0Eq1Y5fQpTD8NmTADI1ptvT8npJZwEkrKuJEFEFgNjVPVbH8QHgKq+k+r+3pz2pGc5LCn5ea71j4jcD0QD/xKRN1JVhXbHqSLNTHvPNYxxVYMKDZjXcx4AqkrfeX3ZdGgTDzR9gMeueuy8voYZEoEbbkhenzULJk6Enj0tAZqAlN0qwCeAIUAo8CfwLbAeSASuBb4SkSki4sqLBBGpAjQB4oCPUu9X1aXAHqAiTgk25b6pqipefKLz4FGMyRIRYUq3KXS9rCtjVo4h8rVIHvnyEXYd3ZX1i40eDevXQ3i4s967t401agJKdhPgQJxk11tVL1PV6zwtbCoA/YHdwF3ATN+EmWVXeJYbVPV0Osf8mOpYYwJCgwoNmNVjFn88+Ad31L+Dt9e8zSWvX8Ldn97N1pit3l9IBCIjne/Hjzsz08fEOOuqcOZMuqca4w+y2/mnGrBMVWel3KiqR4H3RGQuTsnrZhHplfq4PFDds8yom0XSzKTVMzjGKyJSDOjiWa0GlBSRWzzrP6bu7iEig4BBABUqVCA6OjqnIRiTpjvD7+SaK69h9q7ZTPtpGlPWT6Fd+XY8fMnDlAotlbWLPfccJCZCdDRlv/+ey/77X35+9VVOVauWK7Ebk9uymwDjgb/T26mqx0SkN/AXcB+Q1wkwqXXAyQyOOeFZlvDB/cpzYVVr0np/YGrKHao6EZgITj/Adu3a+SAEY9LXk57sO7GPsSvHMn/TfDp36EyRQkU4cuYIpYqUyvoFixWDP/6gWe/eTif63393SovFivk6dGNyTXarQLcDDTI6QFUP4jQSCfgqRlXdnsG7wqlux2cMQMXiFXn5mpf5/YHfKVKoCPEJ8TSa0Ignvnki6xdLmnuwUCGnVNi9O3Tr5vugjclF2U2Ak4F6ItIrk+NOkU4XilyWVLoLy+CYpFLi8VyOxZh8JTjIGdMiQRO4r+l9XHvJtQDsP7mfr//8miwPkB8UBJMnw4gRznpsLLz2Gpw4kfF5xrgsuwnwNWAD8K6IPJ7WASJSHKev3tps3iMntnuWGb2cuDjVsXlKRKJEZOLRo0fduL0xFClUhH+1/hedanQCYMKaCVw3/TqavdOM+X/MJzErAyW1bg1XX+18X7gQHn0UfvjB90Eb40PZSoCqmgBEAQeB0SKyU0T+KyI3i0gbEekDfIdTynoyo2vlkvWeZT0RKZrOMVemOjZPqeoCVR0UntTE3BiXDWs1jIldJxJzOoabZt/E5RMuZ9avs0hITMjahbp1czrRd+zorI8fDyNHOlWlxuQj2R4KzNOysSHwPlAZGIzT8CMaeA+43LOvuGd0lTyjqruAdTj9FG9Nvd8zuHcVnFFiVuZlbMbkV4ULFeaeJvew6aFNvN/9fRISE7jjkzuoM74O765/l7iEOO8vdvnlyWOO/vgjrFjhVJUCnD3r++CNyYYcjYWpqodVtR9OdeIjwAKcpCKez73A10CMiGwSkekiMjhnIXvtRc/yJc+EtQCISHngLc/qaBsQ25jzFQoqRJ+Gffjtgd/4+LaPKR5anIGfDuTSNy7lyy1fZv2CU6fCJ5843w8edIZcmzvXpzEbkx0+GQxaVf9W1TdV9SZVrYxTuroJGIUnAQKXAncAY7N6fRFpLCI/JH2Axp5do1JtTxnTHOBtnNFefhWRBSLyCbAFqAvMwxkU2xiThiAJ4uY6N7N20Fq+uOMLLi55MRHFIgCnwcyJuCw0cilc2FmePAlXXgm1ajnrBw8md643Jo95Ox9goqrmKFmKSCTQDGiiqsOyeG47nAGsM6SqFwwS6pkO6UGcbhtJ0yG9i8vTIYlIFBBVs2bNe7Zs2ZLp8cbkJwPmD+DrP7/mr8F/ERqcg3FCH3wQZs+GHTsgLKNG28ZkX3rzAXqVAE3usQlxjT9avWc1v/7zKwMbD0RVeevHt7i13q2UDyuftQv9+qvTWvSee5z1Dz+EDh0gIsL3QZsCK70E6FWpTkRG5bQhi4iEi8ionFzDGJM/NKvcjIGNBwKw8eBGHv7yYSLHRTL4y8HsPrbb+ws1aJCc/PbtcwbcHjMmFyI25kLeVmsOA/4SkWdEpGpWbiAiVUXkPzjDomVjyAljTH5Wt1xdNj64kdvr385ba96ixms1GLRgEH/G/Jm1C1WsCD//DEOHOuvr1jmT9R454vOYjQHvE2ArnGmPnsFJhN+KyJMi0k5EKohIIQARKeRZby8iT3nmBvwL+DdO45OWufEQxhh31YqoxZRuU9j68FbuaXwP036exmVvXkafT/rw+4Hfvb9Q3brJ1Z/LlsGUKcndKex1jfGxLL0D9DQoeRRoyoVDnMUChVMe7ln+ALymqrOzH2bgsUYwJpDtPb6XV1e+yoQ1EzgZf5JBjQfxv6j/Zf1Cx45ByZLO9+uvhzZt4KmnfBusCXg5egeYRFVnqmoznNacL+J0Ij+Nk+yKeJangOXAc0BjVW1pye9CNhKMCWSVSlRizLVj2PHoDkZcPYJ65esBkJCYwKrdq7y/UFLyi411qkhLlXLWVZ13hsbkgE9agXrmwwsHjmQwAa1Jg7UCNQXJhxs+5PY5t/Ptnd/SsUbH7F9o/ny4/XZYuhSaN/ddgCYg+aQEmB5VPaWqey35GWMycsOlNzApahLtq7cH4L2f3mPBpgVZn4Hi8sth8GBo0sRZ/+EH2LXLx9GaQGf9AF1mJUBTUKkqzd5pxpq/19CwQkOeav0Ut9S95dx0TVm4kNOdolgxWL06d4I1fi1XS4DGGJNVIsLKgSuZdtM04hLi6PlxT+q+VZepP00lPiE+KxeCL76At9921mNjYcgQZ3QZYzLg0wQoIiGebhAXDEnm2V9CRK725T39lc0HaIwz8Padl9/Jhgc28NGtH1EspBj95/fn0jcu5e0f3+bM2TPeXahq1eTq0FWr4M03YevW3AvcBARfNYIRYDTwEE5r0BicQa9f9swdmHRcc2CFqmaxjiNwWRWoMclUlS+2fMHIZSNZuXsllYpXYv2966lQvELWLvTPP1C+vFM6fOUV2LgRJk6EQoVyJ3CTr+V2Fei9wP8BE4C+wFzgWWCJiJT20T2MMQFORLjhshv4fsD3LL5rMXc0uONc8lu4dSFHzhzx7kIVKiR3oD91yulPmJT8rNbFePiqBPgzMFdV/5NiW1PgY+A40FlVd1sJ8EJWAjQmc4dPH+aisRcxoNEAxt8wPusXUHUS4sGDcMklMHo03H9/8v69e+H552HlSli/3neBm3whvRKgr+oDLiHVdEWqusaT8L4EVopIZx/dyxhTwJQuWpqVA1dSpmgZAFbtXsUHv33A0JZDqVyycuYXSCoNBgXBoEHQtq2z/tNPTjKcPx8SEyEuC7PeG7/nqyrQGOCCSnpV3Qe0xRkP9DugtY/uZ4wpYBpVbETVcGcs/lV7VvHG6jeo8XoN7vvsPrYd3ubdRcqUcd4Jli4NDzwATZs68xGeOZOc/BISMr6GCRi+SoBrge5p7VDVY8C1wPfAKz66nzGmAHuk+SNseXgLAxoNYMpPU7j0jUu5a+5dbDyw0bsL9OwJ//tf2smuRYvk74muzZlt8oCvEuBMIFJEyqa1U1VjcRLkJGCnj+7p16wbhDE5U710dd7u+jbbBm/jkeaP8PHGj6n3Vj1u+fAW1u/N5D3e7Nlw331QtCiEpprR/qGHkr83aQJPP+374E2+YCPBuMwawRjjGwdOHuC1Va/xxuo3OBZ7jCndptCvUb+MT9q3z2n8MmWKUxqMi0uedik+HoYNc6pJ77gDTp+GTp1g+HDo0iXXn8f4jk+6QYijj4h8LCI/i8hmEVkuIlNEpKeIlPRdyMYY471yYeV4ocML7Hh0ByM7jKTrZV0B+H7n9yzetjjt8UYrVoTx4+Gvv+Duu6FRo+R9ISEwdqyT/MBpKZq0HZxz7r8ftnn5/tHkO16XAEWkDPA5zlRIaY30osAx4HVglKfa02TCSoDG5K6oWVFs2L+BzQ9vplCQDzvCf/qpkxx//RWqV4e1a53vPXtCkSK+u4/JsfRKgFlJgF8DnXDm//sE+BlnEtzSwKVAG6AqTiL8GeiuqjYYXyYsARqTu86cPcNfh/+ibrm6nI4/zU2zb2LgFQOJPRvLiCUj2Hl0J1XDqzKy40h6N+idtYvHxSW/Q3z8cZgwwelrWLgw/PgjFC8Oder4/qFMluQoAYpIJ+BrYCtwTXqJTUSuB14G6gF/AM1V9XhOAg90lgCNyTt/HPyDmz64iU2HNiEISvLPv2IhxZgYNTHrSTCJKmzf7pQGATp0gP374bffnPUtWyAyMrkK1eSZnL4D7IVTsrsno1Kdqn4JXAl8CtQGXs1GrMYYkytqR9RmwwMbiCgWcV7yAzgVf4rhi4Zn/+IiyckPYNo0mDzZ+a4K7dtDv34pbngq+/cyPuFtAmwK7FLVpZkdqKpncBLmRuAuEamUg/iMMcangoOCOXTqUJr7dh71YS+tKlWSZ6tPTIQ33kgefu3IEYiIgEmTfHc/k2XeJsAqwK/eXtQzM/zTQChwazbiCnjWD9AY9ySNKJOaojwb/azvbxgcDN27Q2vPYFjx8c6M9k09tXI//eRM6rtune/vbdLlbQIsCRzO4rUXACew4c/SpKoLVHVQeHi426EYU+CM7DiSYiHFzttWtFBRul7alZYXtwTgRNwJTsXnUjVluXLw4otwxRXO+pkzzrYqVZz1zz6DgQOdkqLJNd4mwGDgbFYurKpncYZIa5jVoIwxJjf1btCbiVETqRZeDUGoFl6NSTdOYsEdC7jmkmsAeG7pc9QZX4fjsXnQjq9FC1i82JnDEJzZ7JctgxIlnPXZs53qUhu4xKdye3bI/TgtQo0xJl/p3aB3hi0+b6x1I6WLlKZEYScJ/XX4L2qUrpE3wT34oDNYd9IsFh984Ezye889zvrcuVCzplNtarItKyPBNBKRviLSUES8nc/vFGB1fMYYv9O6amuebPMkAOv2ruPSNy6l18e92HEkj7o3S4rxRj75BD7/3PmemOhM6fRqikb2338PsTb2SFZlJQFeDrwLrAdOiMhaEXlHRB4SkVYiUjyd83K7lGmMMbmqVtlaPN3maeb/MZ/a42vz9OKnORF3Iu8CEHGmcAJnTsPffoP//MdZ37vXaVwzdqyzfvas0xnfZMrbjvD9gMaez+VAWIrdmmL5F06CXA/8BAwCutkM8OmzjvDG+I9dR3fx5KInmfHrDCoWr8ioDqPo26gvQeKriXWyITYWFi2CevWgWjX47junz+HXX0PHjs4g30FB55coC5gcD4WW4kIC1CI5ITYGGgGlUhx23kUtAabPEqAx/mfV7lU8+tWj/LD7B66oeAX/ve6/tI1s63ZYju3b4d13YehQKFkS3nkHXn4Zli9PbmRTwPhkNggAdfyhqjNVdaiqdlDVMkBN4DZgNPANcJC0B802xhi/1rxKc1YMWMGsHrM4eOog7d5rx8S1E90OyxEZCc895yQ/gMqVnQ755co56yNHOl0srEWp797PqepfOFWgc5K2iUgVnBKiMcYEFBGhZ/2edKvVjddWvcbNdW4GYGvMVsoVK0d4kXzS/u/6651PkjNnnLkNk6pEn30WLrkE+vRxJz4X2YS4LrMqUGMCh6py1eSriEuIY+2gtUh+f++mCldeCVdd5QzVBk7r0s6dnXeKASK9KlBroWmMMT4iIrx1w1scPHUQESEuIY7vd35P++rt3Q4tbSKwZo0zrRPAnj0wbJgzxVO9ek5J8dtvncY0xYplfC0/5GLTpYLNxgI1JjA1rtSYay+5FoB3179Lh2kdiJoVxaaDm1yOLANJcxpWruxM4XTXXc764sVw443OqDQAMTFOt4sAYQnQJTYWqDGBr3+j/rzc6WWWbl9K/bfr8+jCR4k5HeN2WBkrUwaSfi5dcw188w20a+esv/ceXHSRU1IEZ0onP36NZgnQGGNySeFChXm81eNsfWQrA68YyBur36Dm6zV5fdXrxCfEux1e5kJDoVMnZ4Z7gK5d4a23nJIiwGOPOcOx+WkStARojDG5rHxYeSZ0ncBP9/5Ek4uaMHjhYBq83YDPN3+OXzVEvPTS5DkNwXk32KdPcovS7t2dd4h+whKgMcbkkQYVGvB1n69Z0GsBitJ1VleW7sh0nvH869Zb4V//cr6rOiXDpP6GqnDLLfDpp+7FlwlLgMYYk4dEhK6XdeW3+39jVo9ZtK3mjCDz5ZYvOXDygMvR5YAIvPmmMwINwIEDsHWr03AGnLkNH38c/vzTtRBTswRojDEuCAkOoWf9nogIJ+NO0uvjXjz29WNuh+U75cs7M9337eusr1sHr73mTOsE8NdfMGeO09XCJZYAjTHGZWGhYawcuJIX2r8AwKaDm5i7ca5/vR9MT9L7wQ4dnFkqmjd31j/4AG67DY57JhzesgV27kz/Onv3OnMkXnGFz0KzBGiMMflAnXJ1qFaqGgCvr3qdmz+8mfbvtWf93vUuR+ZDJUtCsGduhCeecDrhJw3Q/eyz0KSJM98hOP0RExOTE1+NGjB5slOq9BEbCs1lNhSaMSa1s4lnmbR2EiOWjCDmdAz9G/XnhQ4vUKlEJbdDyz2bNzvvDLt0cdYvvxyOHnWqTBMTk0ergSx3u/DZbBDGGGNyV6GgQtx/5f1sfWQrj131GO//8j6XvnEpo5aN4nS8e+/MctVllyUnP1VnnsOdO53Bu1MmPx+yBGiMMflUqSKlGHPtGH5/8HeuueQahi8eTu3xtZn92+zAeD+YHhGIjnb6HBYtmjxUm49ZAjTGmHyuZpmazL19LovvWkzpIqXpP78/+07sczus3FWxIowf77QWvfvuXEmElgCNMcZPtK/enrWD1vL9gO+pVKISqsqoZaPYfWy326HlntSJsFEjn13aEqAxxviR4KBgrqjkdAXYdGgTzy19jk835d/RVnwmKRGu912rWJsP0CUiEgVE1axZ0+1QjDF+qnZEbTY9tInKJZ3BqT/47QPiEuLo07APQWLlm8zYn5BLbDokY4wvVCtVjUJBTllmxq8z6DuvL83fac73O793ObL8zxKgMcYEiPk95/N+9/fZe3wvrae05vY5t7P9yHa3w8q3LAEaY0yACJIg+jTsw6aHNvGftv/hs82fUfvN2jy16CmOxx53O7x8xxKgMcYEmLDQMJ5p9wybHtrEbfVu48XlL3LpG5fyzrp3SNREt8PLNywBGmNMgKpSsgrTuk9j1d2ruKTMJby95m23Q8pXLAEaY0yAa1a5Gcv7L2dh74UESRCHTh2izyd92HZ4m9uhucoSoDHGFAAiQrkwZ7b2dXvX8fmWzzkZf9LlqNxlCdAYYwqYay65ht3/t5v65esD8NAXD/HWj29xNvGsy5HlLUuAxhhTAIWFhgEQezaW3w/8zoNfPMjlEy7nq61fuRxZ3rEEaIwxBVjhQoVZdNci5t4+l9izsXSe0ZkuM7qw8cBGt0PLdZYAjTGmgBMRbqp9Exse2MCYa8awYtcKGrzdgIe/eJhDpw65HV6usQRojDEGcEqDQ1oOYcvDWxjUZBBvrXmLmm/U5M3Vb7odWq6wBGiMMeY85cLK8dYNb/HLfb/QrHKzgO0uYQnQGGNMmuqVr8fC3gsZ3Wk0AIv+WkSnaZ34+/jfLkfmG5YAjTHGpEtECAkOAeDQ6UMcjT1KmaJlAPx+WDVLgMYYY7xyW73bWH33aooUKsLp+NM0mtCIl79/mdizsW6Hli2WAI0xxnhNRAA4FnuMaqWqMezbYdQZX4c5v89BVV2OLmssAfqAiNwqIvNEZJeInBSRX0TkfhGbktkYE5gqFK/Agl4L+ObObwgLDePWj26l7dS2rP17rduhec1+QPvGECAWeBzoCswDXgdecjEmY4zJdZ1qdGL9veuZcMME/jj4B1dOupJ+8/r5RUMZ8bcia34kIuVU9UCqbWOB+4FSqppuBXnTpk11zZo1uR2iMcbkuqNnjjJq2SjGrRpHoaBCjLtuHPc0ucftsBCRtaraNPV2KwH6QOrk57EeKAKUyeNwjDHGFeFFwnnpmpfY+OBGrq95PReVuAiAuIS4fPl+0C8SoIjUEpHBIjJdRP4QkUQRURG5xYtz7xCRZSJyVEROiMgaEXkwD97PtQFigP25fB9jjMlXapSuwZzb5nDDZTcA8Gz0s7R6txVnzp5xObLzFXI7AC/dDwzO6kkiMh54ADgDLALigY7Am0BHEblF1fcdWUSkKdAfeFZVE3x9fWOM8Sd1y9XlzNkzFClUBHCqSsOLhLsclZ+8AxSRu4HLgDXAWmAy0Ba4VVXnpHNOD2AOsA+4WlW3eLZXAJYAdYBHVfW1VOeFA5W8CGunqp5K474VgVXAbqCdqsZndBF7B2iMKUh+3vczrd5txWNXPcYTrZ6geGjxXL+nX78DVNV3VPUJVf1QVf/08rQnPcthScnPc61/cEqUAP9Koyq0O7DRi0+z1Df0JM8vgVPAjZklP2OMKWjKFivLjbVu5PnvnueyNy5j6k9TXRtRxi8SYFaJSBWgCRAHfJR6v6ouBfYAFYEWqfZNVVXx4hOd6p5FgE+B8kBnVQ3cOUSMMSabqpSswsweM1kxYAVVw6vSf35/mk1qxrIdy/I8Fn95B5hVV3iWG1T1dDrH/AhU9hy7Iic3E5FCwIdAQ6Ctqu7I5PhBwCCAChUqEB0dnZPbG2OMXxp1ySgWl1jMxG0TuXrq1bSNaMu9Ne6lUlFv3kLlXKAmwOqeZUaJaGeqY3NiPBAFPAEUE5GUpcrfVfVYyoNVdSIwEZx3gO3atfNBCMYY43860IGn4p/i1RWvMvr70axcu5JZPWZxc52bmfHrDIYvGs7OozupGl6VkR1H0rtBb5/dO1ATYNJb1ZMZHHPCsyzhg/td51m+nMa+9kC0D+5hjDEBqVhIMUa0HcGAKwbw7NJnaXVxK2b8OoN7Pr2H02edSrwdR3cwaMEgAJ8lwYB8B5jXVDXS23eFxhhj0la5ZGUmRk2kQvEKPLXoqXPJL8mp+FMMXzTcZ/cL1ASYVLoLy+CYpFLi8VyOJU0iEiUiE48ePerG7Y0xJl/bdXRXmtt3Ht2Z5vbsCNQEuN2zrJbBMRenOjZPqeoCVR0UHu5+Z1BjjMlvqoZXzdL27AjUBLjes6wnIkXTOebKVMcaY4zJJ0Z2HEmxkGLnbSsWUoyRHUf67B4BmQBVdRewDggFbk29X0TaAlVwRolZmbfRGWOMyUzvBr2ZGDWRauHVEIRq4dWYGDXRWoF66UWcTvAvicgKVd0KICLlgbc8x4zOjbFAjTHG5FzvBr19mvBS84sEKCKNSU5aAHU9y1EiMjRpo6q2SPF9joi8jTPs2a8i8i3Jg2GXxJm09s1cDj1dIhIFRNWsWdOtEIwxpkDzl8Gw2+EMYJ0hVZU0zr0DeBBoAAQDfwDvAm/nh9KfDYZtjDG5K73BsP2iBOjpS3dBcvPy3JnATJ8GZIwxxu8FZCMYY4wxJjOWAI0xxhRIlgBdYiPBGGOMu/yiEUwgE5EDZDxrRWYigIM+Cic/CLTngcB7Jnue/C/Qnimnz1NNVcul3mgJ0M+JyJq0Wjf5q0B7Hgi8Z7Lnyf8C7Zly63msCtQYY0yBZAnQGGNMgWQJ0P9NdDsAHwu054HAeyZ7nvwv0J4pV57H3gEaY4wpkKwEaIwxpkCyBGiMMaZAsgToJ0QkREQ6isirIrJGRI6JSJyI7BGROZ4Bw/2OiDwsIh+KyEYROSQi8SJyQES+FZE+IpKtMWDzExEZJSLq+QzN/Iz8RUSmpog/rc8fbseYHSJSVESeEJEfReSIiJwSkW0i8pGItHI7Pm+ISLtM/m5Sfnw3lXoeEJEqIvKGiGwSkdMickZEtojIBBGp4Yt7+MVg2AaAtsA3nu/7gO+AkzhTQ/UAeojI86r6b5fiy65hQHngN2AFzjNVAzrgTF11i4jcnB9m7sgOEbkSeAJQsjmgez7yPbA1je178zqQnBKR6sDXQE2c+JcAZ3H+7d0E/IzzvPndPuC9DPY3A+oAfwK78iQiHxCRK4DFQClgN/CVZ1dT4F6gt4hcp6orcnQjVbWPH3xwEsIcoE0a+27H+c+rQHu3Y83ic7UGwtLYXg/nP7cC/d2OM5vPVhj4HdgDzPU8y1C348rGc0z1xN7P7Vh89DxhOIk8EecXsOBU+8sCl7kdp4+e9XfP391TbseSxbhXeOKeCISk2B4CTPbs+zmn97EqUD+hqotV9RZVXZbGvtk4P6QA+uRpYDmkqstV9WQa2zcA4z2r1+RtVD7zHM5v3/cBNuhr/vE0cAkwXlVfUtWElDtV9ZCqbnYnNN8Rkatw/v0lkPzzId8TkSLAVZ7VZ1Q1Pmmf5/vTntWGIlIsJ/eyBBg41nuWVVyNwrfOepaxrkaRDSLSHBgCzFTVBW7HYxwiEgrc41kd62YseWCAZ7lQVf92NZKsSSD5/35GTgKnc3IjewcYOC71LP3ufUxaPO9o7vOsfupmLFnl+Q32PSAGGOxyOL7UXkQaAsWBf4DlwDfqX+9nm+BUce5R1W0i0hjojvMe+h/ga1Vd7maAvuApGd3uWZ3sZixZparxIrIIuA54VkQeTCoFikgI8Lzn0MnqqRfNLkuAAUBEKgL9PKsfuxhKtolIf5yGPiE4pdiWODUUo1R1rpuxZcNIoBbQU1UDaUT+u9LY9ruI9FTVX/M8muxp4FnuEZExOKX0lEaIyDygT1pV837kVqAEsB/4zOVYsuMBYCFOaf16EVnj2X4lUBoYh9O4LEesCtTPiUghYDoQDizy4+q2VkBf4A7gas+2EST/tucXRKQl8Cgwz/NuNhD8BDyC0+K4OHAR0BWnpWRd4FsRqexadFlTxrO8Aif5jcNpCVoa6IbTYOkm4C0XYvOlpOrPaSnfofkLVf0L55fgL3F+Ib7J86mM07BnmU+ey+3WPvbJcWupd3BaRO0EKrodjw+epyjOD9VXgDicH74XuR1XFmLfDBwGKqXaNxU/bQWawfOGAis9z/Wm2/F4GfNTnngVeD+N/U1xWocmApe4HW82n7Fmimes43Y82XyGljitwDcDN+LMBxiB80vKVs+z/Tun97ESoB8TkdeAgTj/UDqq6j6XQ8oxVT2tqr+r6uPAk8DlwJsuh+WtUTjvYh9T1YB4F5sRVY0DXvSsdnEzliw4nuL7pNQ7VXUNsBanz2bbvArKx5JKfytVdaOrkWSDiJQC5uFU4XZW1U9V9aDnMx/ojNP4ZYSIXJr+lTJnCdBPicirONVSB3CS3xaXQ8oNUz3LKM/L7/yuO07Joa+IRKf84PynBbjfs+0d16L0raRRYPylCnRbOt/TOqZiLsficyISTPK7Wr9q/JLCDUA54Ad1qkLPo6pbgVU4bVja5eRG1gjGD4nIy8BjwCGgk6r+7nJIueUwTnPoQjjvbv5xNxyvBJFxyaGG51MqT6LJfWU9yxOuRuG99Sm+lyXt0VEiPEt/eaaUrsP5ZeQE4K/voJOGbMuo7+wRz7JMBsdkykqAfkZERgOP4ySHa1T1F5dDyk1X4yS/I0C+b02pqpGqKml9SB6u6nHPtkYuhupLt3mWP7oahZdUdQ9O6QGcofbOIyKlgcae1TWp9/uBgZ7lh6rqjwkcIKnPYpO0an4825p4VtMrxXvFEqAfEZEXcIZuOoKT/NZnfEb+JiKtRaSrpyVr6n2tSK7CmaypRusweUNEGnn+joJTbS8kIkNwquEB/pv30WXbSM/yKRFpmrTR03/zbZwW1WtxGvj4DRGJAKI8q/5a/QlOy89TOCXB/4pI4aQdnu+vAxfjFAK+SvMKXrIqUD8hIjcCwz2rW4GH05ko4Q9VHZ1ngeVMTWAKcERE1uE05imBM0xVXc8xn+N0hzDuiMQZxzTG83e0H6fqsAFOd4hE4AlVzdEPorykqgs879CHACtE5Aec1wnNcJ5pD9BLPc0R/cidOP1o/9CcDhLtIlXdLyIP4CTxB4Hunn974JT8KuGMDjVAVXM0xKAlQP+Rsq67qeeTlqWAvyTApTj9/NrgtJ5sidP6bh9Oh/7pqjrPtegMOH39XsNJDnVx/q4UZ4T+KTjjaa51L7zsUdWhIrICeAinT2AxnK5EY4HRqnrAzfiyqb9n+a6rUfiAqr4nIr/i9KltQ/J4wHtwEuNYX7R9EP/7JccYY4zJOXsHaIwxpkCyBGiMMaZAsgRojDGmQLIEaIwxpkCyBGiMMaZAsgRojDGmQLIEaIwxpkCyjvDG+CER2Q5US7FJgZM4w+Rtwhmbc5a/jBUrIgrgGTfVmDxhJUBj/NtXOANtT8MZQ3ErzihB/wJ+FpFPRcTVaX1E5D8ioiLyHzfjMCY1KwEa499Gq2p0yg0iEoQzKPJYz3KpiLRU1UMuxGdMvmUlQGMCjKomembObopTIrwMeNXdqIzJfywBGhOgVPUwzmDCAH1SV4WKSFkReUFEfhWREyJyUkTWicj/pTMP21RPVWY/zzRJ80TkoIicFpG1ItI/jXMUeMaz+oznfM2oSlREbheRlZ6YjovIIhFpnZM/C2PSYgnQmMD2BRADBAPtkzaKSAPgF5wptkoB0Tizc1TDqTr9UkRC07lmc5y58uoD3wArgMuBd0Xk9VTHvoczowSe5XspPj+lvrCIPAfMBOJwpsLaDXQAFonIVd4+tDHesARoTADzzGmXNJdaPQARKQrMx5n77kmguqp2VdUuONNSfYszW/pT6Vz2PmAiUEtVe6lqR6AVcBxnnsouKe7fD5jnWZ2nqv1SfOZxoQeBZqraVlVv98Q8CQgFnsvGH4Ex6bIEaEzgO+hZlvUs+wHVgQ9VdbSqnk06UFVjgL5APPCgpD3r8h6cSXATUpy3iuRZ4f8vB7E+k3J+QVVNJHlC5DZpVc0ak12WAI0JfEn/zxM9y6QS2kdpHayqfwNbgAicEmFqc1Q1No3t73uWrUUkuy3MP0sjnn+Aw0BhkpO4MTlmCdCYwBfhWcZ4ljU8y49SNUo598GZ/R2gXBrX25bOfXbiJNkiZD9R7Uxn+zHPskg2r2vMBawfoDEBzFOFeYVn9VfPMtiz/Jzk6tH05GnfQU+VpzF5whKgMYHtBqA0zju9aM+2XUAt4G1V/Twb14xMZ3tVnFqlM+Rx4jQmO6wK1JgAJSKlSW6YMk1V93u+f+lZ3prNS9+STheJ3p7l9ykb1uB0aQD7hdvkM5YAjQkwIhIkIjfiDIhdE/gDeDzFIRNxSoF9PeN0FkvjGtVFpE86t6gCjPYMuZZ0/JXAY57V11Idv8ezrJPlhzEmF4nTTcgY409SzAbxFbDPs7kITqOVxjid28Hpg3dvitJf0vkNcFpcVsVpHPML8DdQAidR1QRWqWqLFOdMxekiMQHoj5NE13ju2RanhPeWqj6Y6l4VgT+BYsAyz/cE4FNV/dRzTIazQaR43uqquj3TPyBjvGBVEsb4t+s8y5TTIa0FVgMzVfW3tE5S1V9FpCHwANANJ2m2BA7gJLZZwJx07rkKp3P6s577F8VpYPMWMDmNe+0Tka7Av3Ea5LQGBGeUl0+z9LTG+JCVAI0xXklRAuyvqlPdjcaYnLN3gMYYYwokS4DGGGMKJEuAxhhjCiR7B2iMMaZAshKgMcaYAskSoDHGmALJEqAxxpgCyRKgMcaYAskSoDHGmALp/wGxfDrOClUhvQAAAABJRU5ErkJggg==",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plt.figure(1)\n",
    "ax = axes([0.15, 0.15, 0.8, 0.8])\n",
    "\n",
    "\n",
    "def average_encode_state(train_x):\n",
    "    d1, d2 = train_x.shape\n",
    "    density_matrices = np.reshape(train_x, [d1, d2, 1]) @ np.reshape(np.conj(train_x), [d1, 1, d2])\n",
    "    return np.mean(density_matrices, axis=0)\n",
    "\n",
    "\n",
    "depth_list = [2, 3, 4, 6, 8]\n",
    "\n",
    "Q_2Renyi_D3_list = []\n",
    "Q_2Renyi_D6_list = []\n",
    "\n",
    "for i,q in enumerate(qubit_num_list):\n",
    "    train_x, train_y = train_data[i]\n",
    "    train_x = train_x.numpy()\n",
    "    \n",
    "    train_x0 = train_x[train_y == 0]\n",
    "    train_x1 = train_x[train_y == 1]\n",
    "    average_state0 = average_encode_state(train_x0.real)\n",
    "    average_state1 = average_encode_state(train_x1.real)\n",
    "#     print(average_state)\n",
    "    Q_2Renyi_D3 = np.log2(np.trace(average_state0 @ average_state0) * 2 ** q)\n",
    "    Q_2Renyi_D6 = np.log2(np.trace(average_state1 @ average_state1) * 2 ** q)\n",
    "#     bound = np.sum(np.sqrt(S0)) ** 2 / 2 ** num_qubits\n",
    "    Q_2Renyi_D3_list.append(Q_2Renyi_D3)\n",
    "    Q_2Renyi_D6_list.append(Q_2Renyi_D6)\n",
    "\n",
    "print(Q_2Renyi_D3_list)\n",
    "print(Q_2Renyi_D6_list)\n",
    "\n",
    "\n",
    "func3, = ax.plot(depth_list, Q_2Renyi_D3_list, linewidth=1.5,\n",
    "                 marker=\"<\",\n",
    "                 linestyle=\":\",\n",
    "                 color=\"r\"\n",
    "                 )\n",
    "\n",
    "func6, = ax.plot(depth_list, Q_2Renyi_D6_list, linewidth=1.5,\n",
    "                 marker=\"o\",\n",
    "                 linestyle=\"-.\",\n",
    "                 color=\"g\"\n",
    "                 )\n",
    "\n",
    "plt.xticks(fontsize=22)\n",
    "plt.yticks(fontsize=22)\n",
    "\n",
    "plt.xlabel(\"Depth\", fontsize=22)\n",
    "plt.ylabel(r\"$D_2(\\overline{\\rho} || I/2^n)$\", fontsize=22)\n",
    "ax.semilogy()\n",
    "ax.legend(handles=[func3, func6],\n",
    "          labels=[\"Digit 3\", \"Digit 6\"],\n",
    "          loc=\"best\",\n",
    "          fontsize=18)\n",
    "ax.grid(axis=\"y\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 考察分类准确率受到的影响"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[array([0.675], dtype=float32), array([0.61], dtype=float32), array([0.585], dtype=float32), array([0.535], dtype=float32), array([0.475], dtype=float32)]\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "print(acc_list)\n",
    "\n",
    "fig = plt.figure(1)\n",
    "ax = axes([0.15, 0.15, 0.8, 0.8])\n",
    "\n",
    "func36_acc, = ax.plot(depth_list, acc_list, linewidth=1.5,\n",
    "                      marker=\"*\",\n",
    "                      linestyle=\"--\",\n",
    "                      color=\"b\"\n",
    "                      )\n",
    "\n",
    "plt.xticks(fontsize=22)\n",
    "plt.yticks(fontsize=22)\n",
    "plt.ylim(0.48, 0.75)\n",
    "plt.xlabel(\"Depth\", fontsize=22)\n",
    "plt.ylabel(r\"Test Accuracy\", fontsize=22)\n",
    "ax.legend(handles=[func36_acc,],\n",
    "          labels=[\"classifying 3 and 6\"],\n",
    "          loc=\"best\", fontsize=22)\n",
    "ax.grid(axis=\"y\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 总结\n",
    "\n",
    "从实验结果上看每个类别的平均量子态确实随着数据编码电路的加深以指数的速度趋向于最大混合态，从而导致了最终量子神经网络分类准确率下降。在文献 [5] 的帮助下我们逐渐清楚了角度编码存在的一些局限性，同时也体会到了设计一种能够解决实际问题的（通常数据特征维度很高）数据编码策略是迫切需要的，当然也极富挑战性。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## 参考文献\n",
    "\n",
    "[1] Schuld, M. \"Quantum machine learning models are kernel methods.\" [arXiv preprint arXiv:2101.11020.(2021)](https://arxiv.org/abs/2101.11020)\n",
    "\n",
    "[2] Lloyd, Seth, et al. \"Quantum embeddings for machine learning.\" [arXiv preprint arXiv:2001.03622 (2020).](https://arxiv.org/pdf/2001.03622.pdf)\n",
    "\n",
    "[3] Caro, Matthias C., et al. \"Encoding-dependent generalization bounds for parametrized quantum circuits.\" [Quantum 5 (2021): 582.](https://quantum-journal.org/papers/q-2021-11-17-582/)\n",
    "\n",
    "[4] Leonardo Banchi, et al. \"Generalization in quantum machine learning: A quantum information standpoint.\" [PRX Quantum 2.4 (2021): 040321.](https://journals.aps.org/prxquantum/abstract/10.1103/PRXQuantum.2.040321)\n",
    "\n",
    "[5] Li, Guangxi, et al. \"Concentration of Data Encoding in Parameterized Quantum Circuits.\" [arXiv preprint arXiv:2206.08273 (2022).](https://arxiv.org/pdf/2206.08273.pdf)\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.8.13 ('new_pq_dev')",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.13"
  },
  "vscode": {
   "interpreter": {
    "hash": "ea8ffbee42045ec282b7cb9811c8c332764b47a134b1aefa35055ac6f62b46f4"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
